package work.utils;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.CharUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import com.h819.core.utils.MyDateUtils;

/**
 * @Title: StandardBaseUtils.java
 * @Description: TODO(标准号工具类，基础类)
 * @author H819
 * @date 2010-11-18
 * @version V1.0
 */
public class StandardBaseUtils extends StandardContantUtils {

	private static Logger log = Logger.getLogger(StandardBaseUtils.class);

	/**
	 * 该函数用来规范给定的标准号，仅能规范满足 GB 1.1-2000 定义 的标准号；特殊标准号的规范，留作下一步开发
	 * 
	 * @param standardCode
	 *            待验证的标准号
	 * @return 规范后的标准号,无法规范的返回对象 null
	 */

	// 完成功能：
	// 1. 替换常见的错误符号和多余的空格
	// 2. 年号两位的，补全为四位
	// 3. 标准号无空格的，补全空格
	// 4. 经过分析,忘记写"/"的,补上.(根据末位是否包含T或Z)
	// 5. 其他无法规范的，返回 null
	public static String getStandardCode(String standardCode) {

		// GB13693-2005
		// GBZ 2-2002
		// GB T 9634.4-2007
		// GB/T16720.1-2005
		// GB 9634.4-97
		// GB/T 8321.1-2000
		// GB/T11828.2
		// GB/T A13843-1992
		// GB/Y 10001.4-2003
		// DZ 0004-91

		// 为简化多种组合情况,去掉所有的空格，之后手工添加空格
		// GB/T123-97,GB/123-97,GBT123-97

		if (standardCode == null || standardCode.equals("")) {
			log.info("standardCode is null:" + standardCode);
			return null;
		}

		// ====== 预处理 ======
		// 置换常见不合格的字符
		standardCode = getFormatString(standardCode);
		// 去掉所有空格，并转换为大写
		standardCode = StringUtils.deleteWhitespace(standardCode.trim())
				.toUpperCase();

		// ====== 不带年号的标准号的主体部分,下面主要分析这部分======
		// 主体部分
		String mainCode = StringUtils.substringBeforeLast(standardCode, "-");
		// 年号
		String year = StringUtils.substringAfterLast(standardCode, "-");

		log.info("mainCode : " + mainCode);
		log.info("year : " + year);

		/**
		 * 开始处理年份
		 */
		year = MyDateUtils.fillYear2To4(year);

		if (year == null) {
			// log.info("wrong year");
			return null;
		}

		// ====== 开始处理标准号主体部分 ======

		// 统一按照无 "/" 的情况处理

		/**
		 * 开始处理地方标准的情况
		 */
		// 如果是DBxx (xx为数字)开头，认为是地方标准，规范为地方标准
		// 主要规范下面两种情况:
		// 添加空格 DB11/123-2004,DB11/T123-2004
		// 添加 "/" DB11123,DB11T123

		// // 以DBxx (xx为数字)开头
		String mainCodeDB = "";
		if (StringUtils.contains(mainCode, "/"))
			mainCodeDB = StringUtils.substringBefore(mainCode, "/");
		log.info("mainCodeDB : " + mainCodeDB);
		if (mainCodeDB.matches("^" + preDBReg)) {

			// 拆分为类别和标准号
			String kind = mainCode.substring(0, 4);
			String main = mainCode.substring(5, mainCode.length());

			log.info("kind : " + kind);
			log.info("main : " + main);

			// 123、123.4
			if (main.matches(standardCodeReg)) { // 正常格式

				log.info("kind : " + kind);
				return kind + "/" + blankSpace + main + "-" + year;
			}

			// T123、Z123.4的形式
			if (main.charAt(0) == 'T' || main.charAt(0) == 'Z') {
				// 不满足格式要求
				if (!main.substring(1, main.length()).matches(standardCodeReg))
					return null;

				return kind + "/" + CharUtils.toString(main.charAt(0))
						+ blankSpace + StringUtils.substring(main, 1) + "-"
						+ year;
			}
			// 其他情况不可规范
			return null;

		}

		/**
		 * 开始处理开始处理 GB 和 HB
		 */
		mainCode = StringUtils.remove(mainCode, '/');

		// 找到第一个非字母的位置，确定最后一位字母的位置，其之前为标准类别，后面为标准代号
		int index = 0;
		char[] ch = mainCode.toCharArray();
		for (int i = 0; i < ch.length; i++) {
			if (!CharUtils.isAsciiAlpha(ch[i])) {
				index = i;
				break;
			}
		}
		// index = index - 1;
		// 拆分为类别和标准号
		String kind = mainCode.substring(0, index);
		String code = mainCode.substring(index, mainCode.length());

		// log.info("kind :" + kind+", main :" + code);

		if (!code.matches(standardCodeReg))
			return null;

		// 分为三种情况处理
		// HB123-2004; 需要加上空格
		// HB/T123-2004,HB/Z123.3-2004加上空格
		// HBT123-2004,HBZ123-2004;根据情况，加上" "或者"/ "
		//
		// 增加这种情况考虑 GB/15199-1994????

		// 如果是特殊类别，不在进行判断是否是推标或指导性标准
		// // 以 Z 或 T 结尾的合理的类别，不用去掉 Z 或 T 再进一步判断
		if (ArrayUtils.contains(rightClass, kind)) {

			return kind + blankSpace + code + "-" + year;

		} else if ((ch[index - 1] == 'T' || ch[index - 1] == 'Z')
				&& kind.length() > 2) {

			// 标准类别字符超过2个，并且末位字符是 T 或 Z,此时判断才有意义
			//
			// log.info("ch[index-1] :" + ch[index - 1]);
			kind = mainCode.substring(0, index - 1);
			return kind + "/" + CharUtils.toString(ch[index - 1]) + blankSpace
					+ code + "-" + year;
		} else {
			// 不包含 T,Z
			return kind + blankSpace + code + "-" + year;

		}
	}

	/**
	 * 替换字符串中的特殊字符，格式化成标准的英文字符。可以应用的标准题录的各个字段，包括中文名、称英文名称
	 * 
	 * @param stringSource
	 * @return
	 */
	public static String getFormatString(String stringSource) {

		String temp = StringUtils.replace(stringSource, "——", "-");
		temp = StringUtils.replace(stringSource, ": ", ":");
		return temp.replace('－', '-').replace('　', ' ').replace(' ', ' ')
				.replace('—', '-');
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		String standardCode = "DB50/T 374-2010";
		System.out.println(StandardBaseUtils.getStandardCode(standardCode));

	}

}
